Skip to main content
Version: 16.8.2

multiprocessing

Task​

class Task()

__init__​

def __init__(func: Callable,
             args: Optional[tuple] = None,
             kwargs: Optional[dict] = None)

__eq__​

def __eq__(other)

__hash__​

def __hash__()

__repr__​

def __repr__()

TaskResult​

class TaskResult()

timeout_seconds​

timeout_seconds = None

memory_limit_in_gib​

memory_limit_in_gib = None

start_time​

start_time = None

end_time​

end_time = None

elapsed_time​

elapsed_time = None

out_of_memory​

out_of_memory = None

timed_out​

timed_out = None

max_memory_used_in_gib​

max_memory_used_in_gib = None

exit_code​

exit_code = None

__init__​

def __init__(task: Task,
             success: bool,
             result: Any = None,
             exception: Union[Exception, None] = None)

__eq__​

def __eq__(other)

__hash__​

def __hash__()

__repr__​

def __repr__()

execute_task_and_put_in_queue​

def execute_task_and_put_in_queue(task: Task,
                                  queue: "Queue[TaskResult]") -> None

TaskWatcher​

class TaskWatcher()

process​

process = None

start_time​

start_time = None

end_time​

end_time = None

elapsed_time​

elapsed_time = None

__init__​

def __init__(task: Task,
             task_results_queue: "Queue[TaskResult]",
             timeout_seconds: Optional[float] = None,
             memory_limit_in_gib: Optional[float] = None,
             sleep_time: float = 0.001,
             memory_limit_polling_rate: float = 0.1,
             auto_start: bool = True)

start_task​

def start_task() -> None

terminate_task​

def terminate_task() -> None

terminate_task_with_timeout​

def terminate_task_with_timeout() -> None

terminate_task_with_out_of_memory​

def terminate_task_with_out_of_memory() -> None

clean_watcher_queue​

def clean_watcher_queue()

watch_task​

def watch_task() -> None

update_queue​

def update_queue() -> None

psutil​

bytes_to_gigibytes​

def bytes_to_gigibytes(num_bytes: int) -> float

get_total_memory_usage_in_gib​

def get_total_memory_usage_in_gib(pid: Optional[int]) -> float

Calculate the total memory usage of a process and its child processes in gigibytes (GiB).

Arguments:

  • pid int, optional - The process ID for which memory usage is to be calculated. If None, returns 0.0.

Returns:

  • float - The total memory usage of the process and its children in GiB. If pid is None, returns 0.0.

get_available_memory_bytes​

def get_available_memory_bytes() -> int

Returns the available memory in bytes.

get_available_memory_gib​

def get_available_memory_gib() -> float

Returns the available memory in gigabytes.

GlasswallProcessManager​

class GlasswallProcessManager()

__init__​

def __init__(max_workers: Optional[int] = None,
             worker_timeout_seconds: Optional[float] = None,
             memory_limit_in_gib: Optional[float] = None)

__enter__​

def __enter__()

__exit__​

def __exit__(exc_type, exc_val, exc_tb)

queue_task​

def queue_task(task: Task)

as_completed​

def as_completed() -> Generator[TaskResult, None, None]

start_tasks​

def start_tasks()

wait_for_completed_process​

def wait_for_completed_process()

remove_completed_active_processes​

def remove_completed_active_processes()

clean_task_results_queue​

def clean_task_results_queue()
Last updated on